#include "../exercise.h"

// READ: 复制构造函数 <https://zh.cppreference.com/w/cpp/language/copy_constructor>
// READ: 函数定义（显式弃置）<https://zh.cppreference.com/w/cpp/language/function>


class DynFibonacci {
    size_t *cache;
    int cached;
    int capacity;

public:
    // TODO: 实现动态设置容量的构造器
    DynFibonacci(int capacity) 
        : cache(new size_t[capacity]), cached(0), capacity(capacity) {
        // 初始化基础值
        if (capacity > 0) {
            cache[0] = 0;
            cached = 1;
        }
        if (capacity > 1) {
            cache[1] = 1;
            cached = 2;
        }
    }

    // TODO: 实现复制构造器
    DynFibonacci(DynFibonacci const &other) 
        : cache(new size_t[other.capacity]), 
          cached(other.cached), 
          capacity(other.capacity) {
        // 复制缓存数据
        for (int i = 0; i < cached; ++i) {
            cache[i] = other.cache[i];
        }
    }

    // TODO: 实现析构器，释放缓存空间
    ~DynFibonacci() {
        delete[] cache;
    }

    // TODO: 实现正确的缓存优化斐波那契计算
    size_t get(int i) {
        // 边界检查
        if (i < 0 || i >= capacity) {
            ASSERT(false, "i out of range");
            return 0;
        }
        
        // 如果请求的索引已经在缓存中，直接返回
        if (i < cached) {
            return cache[i];
        }
        
        // 计算并缓存缺失的值
        for (int j = cached; j <= i; ++j) {
            if (j == 0) {
                cache[j] = 0;
            } else if (j == 1) {
                cache[j] = 1;
            } else {
                cache[j] = cache[j - 1] + cache[j - 2];
            }
        }
        
        // 更新已缓存的数量
        cached = i + 1;
        
        return cache[i];
    }

    // NOTICE: 不要修改这个方法
    // NOTICE: 名字相同参数也相同，但 const 修饰不同的方法是一对重载方法，可以同时存在
    //         本质上，方法是隐藏了 this 参数的函数
    //         const 修饰作用在 this 上，因此它们实际上参数不同
    size_t get(int i) const {
        if (i <= cached) {
            return cache[i];
        }
        ASSERT(false, "i out of range");
    }
};

int main(int argc, char **argv) {
    DynFibonacci fib(12);
    ASSERT(fib.get(10) == 55, "fibonacci(10) should be 55");
    DynFibonacci const fib_ = fib;
    ASSERT(fib_.get(10) == fib.get(10), "Object cloned");
    return 0;
}

/*
复制构造函数：DynFibonacci(DynFibonacci const &other) 
使用名字叫other

深拷贝，new新的大小一致的空间；复制数组的所有值

为什么要额外加一个const的同名函数？
因为你可能会创造一个const的类对象，而它要求所有的成员函数也是const的

上一题：
class DynFibonacci {
    size_t *cache;
    int cached;
    int capacity;

public:
    // TODO: 实现动态设置容量的构造器
    DynFibonacci(int capacity) 
        : cache(new size_t[capacity]), cached(0), capacity(capacity) {
        // 初始化基础值
        if (capacity > 0) {
            cache[0] = 0;
            cached = 1;
        }
        if (capacity > 1) {
            cache[1] = 1;
            cached = 2;
        }
    }

    // TODO: 实现析构器，释放缓存空间
    ~DynFibonacci() {
        delete[] cache;
    }

    // TODO: 实现正确的缓存优化斐波那契计算
    size_t get(int i) {
        // 边界检查
        if (i < 0 || i >= capacity) {
            return 0;  // 或者抛出异常
        }
        
        // 如果请求的索引已经在缓存中，直接返回
        if (i < cached) {
            return cache[i];
        }
        
        // 计算并缓存缺失的值
        for (int j = cached; j <= i; ++j) {
            if (j == 0) {
                cache[j] = 0;
            } else if (j == 1) {
                cache[j] = 1;
            } else {
                cache[j] = cache[j - 1] + cache[j - 2];
            }
        }
        
        // 更新已缓存的数量
        cached = i + 1;
        
        return cache[i];
    }
};
*/